package com.gonsin.ta.logic.process;

import com.gonsin.ta.logic.exceptions.TaException;
import com.gonsin.ta.logic.node.Node;
import com.gonsin.ta.logic.parse.Chain;
import org.springframework.context.ApplicationContext;

import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;

public class TaBus {

    /**
     * 本地已缓存的所有任务总集合
     */
    private static final Map<String, Chain> chainMap = new ConcurrentHashMap<>();
    // 编译中的流程脚本
    private static final Map<String, Chain> compilingChainMap = new ConcurrentHashMap<>();
    public static ApplicationContext APPLICATION_CONTEXT;

    /**
     * 是否已初始化
     */
    private static volatile boolean init = false;


    /**
     * 节点缓存
     */
    private static final Map<String, Node> nodeMap = new ConcurrentHashMap<>();
    // 编译中的流程脚本
    private static final Map<String, Node> compilingNodeMap = new ConcurrentHashMap<>();


    private TaBus() {}

    /**
     * 获取一个看可执行任务链
     */
    public static Chain getChain(String id){
        return chainMap.get(id);
    }

    /**
     * 查询编译中的流程脚本
     */
    public static Chain getCompilingChain(String id){
        return compilingChainMap.get(id);
    }


    /**
     * 获取节点
     */
    public static Node getNode(String nodeId) {
        return nodeMap.get(nodeId);
    }

    /**
     * 清空缓存，用于热刷新
     */
    public static void cleanCache() {
        chainMap.clear();
        nodeMap.clear();
        init = false;
    }

    /**
     * 获取所有的chain
     * @return
     */
    public static Map<String, Chain> getChainMap() {
        return chainMap;
    }


    /**
     * 获取所有节点
     */
    public static Map<String, Node> getNodeMap(){
        return nodeMap;
    }

    /**
     * 添加流程定义
     */
    public static void addChain(Chain chain, boolean replace) {
        // 判断名字重复
        if(!replace){
            if(chainMap.containsKey(chain.getChainId())){
                throw new TaException("chainId = 【{}】有重复", chain.getChainId());
            }
        }
        chainMap.put(chain.getChainId(), chain);
    }

    /**
     * 添加流程定义
     */
    public static void addNode(Node node, boolean replace) {
        // 判断名字重复
        if(!replace){
            if(nodeMap.containsKey(node.getNodeId())){
                throw new TaException("nodeId = 【{}】有重复", node.getNodeId());
            }
        }
        nodeMap.put(node.getNodeId(), node);
    }

    /**
     * 是否初始化
     */
    public static boolean isInit() {
        return init;
    }

    public static void notifyInitFinished() {
        init = true;
    }
}
